home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / fax / src / util / Str.c++ < prev    next >
C/C++ Source or Header  |  1994-08-01  |  15KB  |  673 lines
  1. /*    $Header: /usr/people/sam/fax/util/RCS/Str.c++,v 1.17 1994/02/28 14:24:21 sam Rel $ */
  2. /*
  3.  * Copyright (c) 1990, 1991, 1992, 1993, 1994 Sam Leffler
  4.  * Copyright (c) 1991, 1992, 1993, 1994 Silicon Graphics, Inc.
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and 
  7.  * its documentation for any purpose is hereby granted without fee, provided
  8.  * that (i) the above copyright notices and this permission notice appear in
  9.  * all copies of the software and related documentation, and (ii) the names of
  10.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  11.  * publicity relating to the software without the specific, prior written
  12.  * permission of Sam Leffler and Silicon Graphics.
  13.  * 
  14.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  15.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  16.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  17.  * 
  18.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  19.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  20.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  22.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  23.  * OF THIS SOFTWARE.
  24.  */
  25. #include "Str.h"
  26. #include <stdlib.h>
  27. #include <ctype.h>
  28.  
  29. #define NUMBUFSIZE 2048
  30. char fxStr::emptyString = '\0';
  31.  
  32. fxStr::fxStr(u_int l)
  33. {
  34.     slength = l+1;
  35.     if (l>0) {
  36.     data = new char[slength];
  37.     } else
  38.     data = &emptyString;
  39.     memset(data,0,slength);
  40. }
  41.  
  42. fxStr::fxStr(const char *s)
  43. {
  44.     u_int l = strlen(s)+1;
  45.     if (l>1) {
  46.     data = new char[l];
  47.     memcpy(data,s,l);
  48.     } else {
  49.     data = &emptyString;
  50.     }
  51.     slength = l;
  52. }
  53.  
  54. fxStr::fxStr(const char *s, u_int len)
  55. {
  56.     if (len>0) {
  57.     data = new char[len+1];
  58.     memcpy(data,s,len);
  59.     } else
  60.     data = &emptyString;
  61.     slength = len+1;
  62.     data[len] = 0;
  63. }
  64.  
  65. fxStr::fxStr(const fxStr&s)
  66. {
  67.     slength = s.slength;
  68.     if (slength > 1) {
  69.     data = new char[slength];
  70.     memcpy(data,s.data,slength);
  71.     } else {
  72.     data = &emptyString;
  73.     }
  74. }
  75.  
  76. fxStr::fxStr(const fxTempStr &t)
  77. {
  78.     slength = t.slength;
  79.     if (t.slength>1) {
  80.     data = new char[slength];
  81.     memcpy(data,t.data,slength);
  82.     } else {
  83.     data = &emptyString;
  84.     }
  85. }
  86.  
  87. fxStr::fxStr(int a, const char * format)
  88. {
  89.     char buffer[NUMBUFSIZE];
  90.     if (!format) format = "%d";
  91.     sprintf(buffer,format,a);
  92.     slength = strlen(buffer) + 1;
  93.     data = new char[slength];
  94.     memcpy(data,buffer,slength);
  95. }
  96.  
  97. fxStr::fxStr(long a, const char * format)
  98. {
  99.     char buffer[NUMBUFSIZE];
  100.     if (!format) format = "%ld";
  101.     sprintf(buffer,format,a);
  102.     slength = strlen(buffer) + 1;
  103.     data = new char[slength];
  104.     memcpy(data,buffer,slength);
  105. }
  106.  
  107. fxStr::fxStr(float a, const char * format)
  108. {
  109.     char buffer[NUMBUFSIZE];
  110.     if (!format) format = "%g";
  111.     sprintf(buffer,format,a);
  112.     slength = strlen(buffer) + 1;
  113.     fxAssert(slength>1, "Str::Str(float): bogus conversion");
  114.     data = new char[slength];
  115.     memcpy(data,buffer,slength);
  116. }
  117.  
  118. fxStr::fxStr(double a, const char * format)
  119. {
  120.     char buffer[NUMBUFSIZE];
  121.     if (!format) format = "%lg";
  122.     sprintf(buffer,format,a);
  123.     slength = strlen(buffer) + 1;
  124.     fxAssert(slength>1, "Str::Str(double): bogus conversion");
  125.     data = new char[slength]; // XXX assume slength>1
  126.     memcpy(data,buffer,slength);
  127. }
  128.  
  129. fxStr::~fxStr()
  130. {
  131.     assert(data);
  132.     if (data != &emptyString) delete data;
  133. }
  134.  
  135. fxStr fxStr::extract(u_int start, u_int chars) const
  136. {
  137.     fxAssert(start+chars<slength, "Str::extract: Invalid range");
  138.     return fxStr(data+start,chars);
  139. }
  140.  
  141. fxStr fxStr::head(u_int chars) const
  142. {
  143.     fxAssert(chars<slength, "Str::head: Invalid size");
  144.     return fxStr(data,chars);
  145. }
  146.  
  147. fxStr fxStr::tail(u_int chars) const
  148. {
  149.     fxAssert(chars<slength, "Str::tail: Invalid size");
  150.     return fxStr(data+slength-chars-1,chars);
  151. }
  152.  
  153. void fxStr::lowercase()
  154. {
  155.     char* cp = data;
  156.     for (int i = slength; i > 0; i--, cp++) {
  157. #ifdef _tolower
  158.     char c = *cp;
  159.     if (isupper(c))
  160.         *cp = _tolower(c);
  161. #else
  162.     *cp = tolower(*cp);
  163. #endif
  164.     }
  165. }
  166.  
  167. void fxStr::raisecase()
  168. {
  169.     char* cp = data;
  170.     for (int i = slength; i > 0; i--, cp++) {
  171. #ifdef _toupper
  172.     char c = *cp;
  173.     if (islower(c))
  174.         *cp = _toupper(c);
  175. #else
  176.     *cp = toupper(*cp);
  177. #endif
  178.     }
  179. }
  180.  
  181. fxStr fxStr::copy() const
  182. {
  183.     return fxStr(data,slength-1);
  184. }
  185.  
  186. void fxStr::remove(u_int start, u_int chars)
  187. {
  188.     fxAssert(start+chars<slength,"Str::remove: Invalid range");
  189.     long move = slength-start-chars;        // we always move at least 1
  190.     assert(move > 0);
  191.     if (slength - chars <= 1) {
  192.     resizeInternal(0);
  193.     slength = 1;
  194.     } else {
  195.     memmove(data+start, data+start+chars, (u_int)move);
  196.     slength -= chars;
  197.     }
  198. }
  199.  
  200. fxStr fxStr::cut(u_int start, u_int chars)
  201. {
  202.     fxAssert(start+chars<slength,"Str::cut: Invalid range");
  203.     fxStr a(data+start, chars);
  204.     remove(start, chars);
  205.     return a;
  206. }
  207.  
  208. void fxStr::insert(const char * v, u_int posn, u_int len)
  209. {
  210.     if (!len) len = strlen(v);
  211.     if (!len) return;
  212.     fxAssert(posn<slength, "Str::insert: Invalid index");
  213.     u_int move = slength - posn;
  214.     u_int nl = slength + len;
  215.     resizeInternal(nl);
  216.     /*
  217.      * When move is one we are always moving \0; but beware
  218.      * that the previous string might have been null before
  219.      * the call to resizeInternal; so set the byte explicitly.
  220.      */
  221.     if (move == 1)
  222.     data[posn+len] = '\0';
  223.     else
  224.     memmove(data+posn+len, data+posn, move);
  225.     memcpy(data+posn, v, len);
  226.     slength = nl;
  227. }
  228.  
  229. void fxStr::insert(char a, u_int posn)
  230. {
  231.     u_int nl = slength + 1;
  232.     resizeInternal(nl);
  233.     long move = (long)slength - (long)posn;
  234.     fxAssert(move>0, "Str::insert(char): Invalid index");
  235.     /*
  236.      * When move is one we are always moving \0; but beware
  237.      * that the previous string might have been null before
  238.      * the call to resizeInternal; so set the byte explicitly.
  239.      */
  240.     if (move == 1)
  241.     data[posn+1] = '\0';
  242.     else
  243.     memmove(data+posn+1, data+posn, (size_t) move);    // move string tail
  244.     data[posn] = a;
  245.     slength = nl;
  246. }
  247.  
  248. void fxStr::resizeInternal(u_int chars)
  249. {
  250.     if (slength > 1) {
  251.     if (chars > 0) {
  252.         if (chars >= slength)
  253.         data = (char *)realloc(data,chars+1);
  254.     } else {
  255.         assert(data != &emptyString);
  256.         free(data);
  257.         data = &emptyString;
  258.     }
  259.     } else {
  260.     assert(data == &emptyString);
  261.     if (chars)
  262.         data = new char[chars+1];
  263.     }
  264. }
  265.  
  266.  
  267. void fxStr::resize(u_int chars, fxBool)
  268. {
  269.     resizeInternal(chars);
  270.     if (chars>=slength)
  271.     memset(data+slength, 0, chars+1-slength);
  272.     slength = chars+1;
  273.     data[chars] = 0;
  274. }
  275.  
  276. void fxStr::setMaxLength(u_int len)
  277. {
  278.     if (slength>1) resizeInternal(fxmax(len,slength-1));
  279. }
  280.  
  281. void fxStr::operator=(const fxTempStr& s)
  282. {
  283.     resizeInternal(s.slength-1);
  284.     memcpy(data,s.data,s.slength);
  285.     slength = s.slength;
  286. }
  287.  
  288. void fxStr::operator=(const fxStr& s)
  289. {
  290.     resizeInternal(s.slength-1);
  291.     memcpy(data,s.data,s.slength);
  292.     slength = s.slength;
  293. }
  294.  
  295. void fxStr::operator=(const char *s)
  296. {
  297.     u_int nl = strlen(s) + 1;
  298.     resizeInternal(nl-1);
  299.     slength = nl;
  300.     memcpy(data,s,slength);
  301. }
  302.  
  303. void fxStr::append(const char * s, u_int l)
  304. {
  305.     if (!l) l = strlen(s);
  306.     if (!l) return;
  307.     u_int nl = slength + l;
  308.     resizeInternal(nl-1);
  309.     memcpy(data+slength-1, s, l);
  310.     slength = nl;
  311.     data[slength-1] = 0;
  312. }
  313.  
  314. void fxStr::append(char a)
  315. {
  316.     resizeInternal(slength);
  317.     slength++;
  318.     data[slength-2] = a;
  319.     data[slength-1] = 0;
  320. }
  321.  
  322. fxBool operator==(const fxStr& a,const fxStr& b)
  323. {
  324.     return (a.slength == b.slength) && (memcmp(a.data,b.data,a.slength) == 0);
  325. }
  326.  
  327. fxBool operator==(const fxStr& a,const char* b)
  328. {
  329.     return (a.slength == strlen(b)+1) && (memcmp(a.data,b,a.slength) == 0);
  330. }
  331.  
  332. fxBool operator==(const char* b, const fxStr& a)
  333. {
  334.     return (a.slength == strlen(b)+1) && (memcmp(a.data,b,a.slength) == 0);
  335. } 
  336.  
  337. fxBool operator!=(const fxStr& a,const fxStr& b)
  338. {
  339.     return (a.slength != b.slength) || (memcmp(a.data,b.data,a.slength) != 0);
  340. }
  341.  
  342. fxBool operator!=(const fxStr& a,const char* b)
  343. {
  344.     return (a.slength != strlen(b)+1) || (memcmp(a.data,b,a.slength) != 0);
  345. }
  346.  
  347. fxBool operator!=(const char* b, const fxStr& a)
  348. {
  349.     return (a.slength != strlen(b)+1) || (memcmp(a.data,b,a.slength) != 0);
  350. } 
  351.  
  352. fxBool operator>=(const fxStr& a,const fxStr& b)
  353. {
  354.     return strcmp(a,b) >= 0;
  355. }
  356.  
  357. fxBool operator>=(const fxStr& a,const char* b)
  358. {
  359.     return strcmp(a,b) >= 0;
  360. }
  361.  
  362. fxBool operator>=(const char* a, const fxStr& b)
  363. {
  364.     return strcmp(a,b) >= 0;
  365. } 
  366.  
  367. fxBool operator>(const fxStr& a,const fxStr& b)
  368. {
  369.     return strcmp(a,b) > 0;
  370. }
  371.  
  372. fxBool operator>(const fxStr& a,const char* b)
  373. {
  374.     return strcmp(a,b) > 0;
  375. }
  376.  
  377. fxBool operator>(const char* a, const fxStr& b)
  378. {
  379.     return strcmp(a,b) > 0;
  380. } 
  381.  
  382. fxBool operator<=(const fxStr& a,const fxStr& b)
  383. {
  384.     return strcmp(a,b) <= 0;
  385. }
  386.  
  387. fxBool operator<=(const fxStr& a,const char* b)
  388. {
  389.     return strcmp(a,b) <= 0;
  390. }
  391.  
  392. fxBool operator<=(const char* a, const fxStr& b)
  393. {
  394.     return strcmp(a,b) <= 0;
  395. } 
  396.  
  397. fxBool operator<(const fxStr& a,const fxStr& b)
  398. {
  399.     return strcmp(a,b) < 0;
  400. }
  401.  
  402. fxBool operator<(const fxStr& a,const char* b)
  403. {
  404.     return strcmp(a,b) < 0;
  405. }
  406.  
  407. fxBool operator<(const char* a, const fxStr& b)
  408. {
  409.     return strcmp(a,b) < 0;
  410. } 
  411.  
  412. int compare(const fxStr&a, const fxStr&b)
  413. {
  414.     return strcmp(a,b);
  415. }
  416.  
  417. int compare(const fxStr&a, const char*b)
  418. {
  419.     return strcmp(a,b);
  420. }
  421.  
  422. int compare(const char *a, const char *b)
  423. {
  424.     return strcmp(a,b);
  425. }
  426.  
  427.  
  428. static int quickFind(char a, const char * buf, u_int buflen)
  429. {
  430.     while (buflen--)
  431.     if (*buf++ == a) return 1;
  432.     return 0;
  433. }
  434.  
  435. u_int fxStr::next(u_int posn, char a) const
  436. {
  437.     fxAssert(posn<slength, "Str::next: invalid index");
  438.     char * buf = data+posn;
  439.     u_int counter = slength-1-posn;
  440.     while (counter--) {
  441.     if (*buf == a) return (buf-data);
  442.     buf++;
  443.     }
  444.     return slength-1;
  445. }
  446.  
  447. u_int fxStr::next(u_int posn, const char * c, u_int clen) const
  448. {
  449.     fxAssert(posn<slength, "Str::next: invalid index");
  450.     char * buf = data + posn;
  451.     u_int counter = slength-1-posn;
  452.     if (!clen) clen = strlen(c);
  453.     while (counter--) {
  454.     if (quickFind(*buf,c,clen)) return (buf-data);
  455.     buf++;
  456.     }
  457.     return slength-1;
  458. }
  459.  
  460. u_int fxStr::nextR(u_int posn, char a) const
  461. {
  462.     fxAssert(posn<slength, "Str::nextR: invalid index");
  463.     char * buf = data + posn - 1;
  464.     u_int counter = posn;
  465.     while (counter--) {
  466.     if (*buf == a) return (buf-data+1);
  467.     buf--;
  468.     }
  469.     return 0;
  470. }
  471.  
  472. u_int fxStr::nextR(u_int posn, const char * c, u_int clen) const
  473. {
  474.     fxAssert(posn<slength, "Str::nextR: invalid index");
  475.     char * buf = data + posn - 1;
  476.     u_int counter = posn;
  477.     if (!clen) clen = strlen(c);
  478.     while (counter--) {
  479.     if (quickFind(*buf,c,clen)) return (buf-data+1);
  480.     buf--;
  481.     }
  482.     return 0;
  483. }
  484.  
  485. u_int fxStr::skip(u_int posn, char a) const
  486. {
  487.     fxAssert(posn<slength, "Str::skip: invalid index");
  488.     char * buf = data+posn;
  489.     u_int counter = slength-1-posn;
  490.     while (counter--) {
  491.     if (*buf != a) return (buf-data);
  492.     buf++;
  493.     }
  494.     return slength-1;
  495. }
  496.  
  497. u_int fxStr::skip(u_int posn, const char * c, u_int clen) const
  498. {
  499.     fxAssert(posn<slength, "Str::skip: invalid index");
  500.     char * buf = data + posn;
  501.     u_int counter = slength-1-posn;
  502.     if (!clen) clen = strlen(c);
  503.     while (counter--) {
  504.     if (!quickFind(*buf,c,clen)) return (buf-data);
  505.     buf++;
  506.     }
  507.     return slength-1;
  508. }
  509.  
  510. u_int fxStr::skipR(u_int posn, char a) const
  511. {
  512.     fxAssert(posn<slength, "Str::skipR: invalid index");
  513.     char * buf = data + posn - 1;
  514.     u_int counter = posn;
  515.     while (counter--) {
  516.     if (*buf != a) return (buf-data+1);
  517.     buf--;
  518.     }
  519.     return 0;
  520. }
  521.  
  522. u_int fxStr::skipR(u_int posn, const char * c, u_int clen) const
  523. {
  524.     fxAssert(posn<slength, "Str::skipR: invalid index");
  525.     char * buf = data + posn - 1;
  526.     u_int counter = posn;
  527.     if (!clen) clen = strlen(c);
  528.     while (counter--) {
  529.     if (!quickFind(*buf,c,clen)) return (buf-data+1);
  530.     buf--;
  531.     }
  532.     return 0;
  533. }
  534.  
  535. fxStr fxStr::token(u_int & posn, const char * delim, u_int dlen) const
  536. {
  537.     fxAssert(posn<slength, "Str::token: invalid index");
  538.     if (!dlen) dlen = strlen(delim);
  539.     u_int end = next(posn, delim, dlen);
  540.     u_int old = posn;
  541.     posn = skip(end, delim, dlen);
  542.     return extract(old,end-old);
  543. }
  544.  
  545. fxStr fxStr::token(u_int & posn, char a) const
  546. {
  547.     fxAssert(posn<slength, "Str::token: invalid index");
  548.     u_int end = next(posn, a);
  549.     u_int old = posn;
  550.     posn = skip(end, a);
  551.     return extract(old,end-old);
  552. }
  553.  
  554. fxStr fxStr::tokenR(u_int & posn, const char * delim, u_int dlen) const
  555. {
  556.     fxAssert(posn<slength, "Str::tokenR: invalid index");
  557.     if (!dlen) dlen = strlen(delim);
  558.     u_int begin = nextR(posn, delim, dlen);
  559.     u_int old = posn;
  560.     posn = skipR(begin, delim, dlen);
  561.     return extract(begin, old-begin);
  562. }
  563.  
  564. fxStr fxStr::tokenR(u_int & posn, char a) const
  565. {
  566.     fxAssert(posn<slength, "Str::tokenR: invalid index");
  567.     u_int begin = nextR(posn, a);
  568.     u_int old = posn;
  569.     posn = skipR(begin, a);
  570.     return extract(begin,old-begin);
  571. }
  572.  
  573. u_long fxStr::hash() const
  574. {
  575.     char * elementc = data;
  576.     u_int slen = slength - 1;
  577.     u_long k = 0;
  578.     if (slen < 2*sizeof(k)) {
  579.     if (slen <= sizeof(k)) {
  580.         memcpy((char *)&k + (sizeof(k) - slen), elementc, slen);
  581.         k<<=3;
  582.     } else {
  583.         memcpy((char *)&k + (sizeof(k)*2 - slen), elementc, slen-sizeof(k));
  584.         k<<=3;
  585.         k ^= *(u_long *)elementc;
  586.     }
  587.     } else {
  588.     k = *(u_long *)(elementc + sizeof(k));
  589.     k<<=3;
  590.     k ^= *(u_long *)elementc;
  591.     }
  592.     return k;
  593. }
  594.  
  595. //--- concatenation support ----------------------------------
  596.  
  597. fxTempStr::fxTempStr(const char *d1, u_int l1, const char *d2, u_int l2)
  598. {
  599.     slength = l1 + l2 + 1;
  600.     if (slength <= sizeof(indata)) {
  601.     data = &indata[0];
  602.     } else {
  603.     data = new char[slength];
  604.     }
  605.     memcpy(data,d1,l1);
  606.     memcpy(data+l1,d2,l2);
  607.     data[l1+l2] = 0;
  608. }
  609.  
  610. fxTempStr::fxTempStr(fxTempStr const &other)
  611. {
  612.     slength = other.slength;
  613.     if (slength <= sizeof (indata)) {
  614.     data = &indata[0];
  615.     } else {
  616.     data = new char[slength];
  617.     }
  618.     memcpy(data, other.data, slength);
  619.     data[slength] = 0;
  620. }
  621.  
  622. fxTempStr::~fxTempStr()
  623. {
  624.     if (data != indata) delete data;
  625. }
  626.  
  627. fxTempStr& operator|(const fxTempStr& ts, const fxStr &b)
  628. {
  629.     return ((fxTempStr &)ts).concat(b.data, b.slength-1);
  630. }
  631.  
  632. fxTempStr& operator|(const fxTempStr& ts, const char *b)
  633. {
  634.     return ((fxTempStr &)ts).concat(b, strlen(b));
  635. }
  636.  
  637. fxTempStr& fxTempStr::concat(const char* b, u_int bl)
  638. {
  639.     if (slength <= sizeof(indata)) {
  640.     // Current temporary is in the internal buffer.  See if the
  641.     // concatenation will fit too.
  642.     if (slength + bl > sizeof(indata)) {
  643.         // Have to malloc.
  644.         data = (char*) malloc(slength + bl);
  645.         memcpy(data, indata, slength - 1);
  646.     }
  647.     } else {
  648.     // Temporary is already too large.
  649.     data = (char*) realloc(data, slength + bl);
  650.     }
  651.  
  652.     // concatenate data
  653.     memcpy(data+slength-1, b, bl);
  654.     slength += bl;
  655.     data[slength-1] = 0;
  656.     return *this;
  657. }
  658.  
  659. fxTempStr operator|(const fxStr &a, const fxStr &b)
  660. {
  661.     return fxTempStr(a.data, a.slength-1, b.data, b.slength-1);
  662. }
  663.  
  664. fxTempStr operator|(const fxStr &a, const char *b)
  665. {
  666.     return fxTempStr(a.data, a.slength-1, b, strlen(b));
  667. }
  668.  
  669. fxTempStr operator|(const char *a, const fxStr &b)
  670. {
  671.     return fxTempStr(a, strlen(a), b.data, b.slength-1);
  672. }
  673.